home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / libol / io.h.x < prev    next >
Encoding:
Text File  |  2005-10-16  |  6.7 KB  |  299 lines
  1. #ifndef CLASS_DEFINE
  2. struct fd_callback
  3. {
  4.   struct ol_object super;
  5.   int (*(f))(struct fd_callback **self, int fd);
  6. };
  7. extern struct ol_class fd_callback_class;
  8. #endif /* !CLASS_DEFINE */
  9.  
  10. #ifndef CLASS_DECLARE
  11. struct ol_class fd_callback_class =
  12. { STATIC_HEADER,
  13.   0, "fd_callback", sizeof(struct fd_callback),
  14.   NULL,
  15.   NULL
  16. };
  17. #endif /* !CLASS_DECLARE */
  18.  
  19. #ifndef CLASS_DEFINE
  20. struct close_callback
  21. {
  22.   struct ol_object super;
  23.   int (*(f))(struct close_callback *self, int reason);
  24. };
  25. extern struct ol_class close_callback_class;
  26. #endif /* !CLASS_DEFINE */
  27.  
  28. #ifndef CLASS_DECLARE
  29. struct ol_class close_callback_class =
  30. { STATIC_HEADER,
  31.   0, "close_callback", sizeof(struct close_callback),
  32.   NULL,
  33.   NULL
  34. };
  35. #endif /* !CLASS_DECLARE */
  36.  
  37. #ifndef CLASS_DEFINE
  38. struct nonblocking_fd
  39. {
  40.   struct resource super;
  41.   struct nonblocking_fd *next;
  42.   int fd;
  43.   struct ol_string *fname;
  44.   int to_be_closed;
  45.   int close_reason;
  46.   struct close_callback *close_callback;
  47.   void (*(prepare))(struct nonblocking_fd *self);
  48.   int want_read;
  49.   void (*(read))(struct nonblocking_fd *self);
  50.   int want_write;
  51.   void (*(write))(struct nonblocking_fd *self);
  52.   void (*(really_close))(struct nonblocking_fd *self);
  53. };
  54. extern struct ol_class nonblocking_fd_class;
  55. #endif /* !CLASS_DEFINE */
  56.  
  57. #ifndef CLASS_DECLARE
  58. static void do_nonblocking_fd_mark(struct ol_object *o, 
  59. void (*mark)(struct ol_object *o))
  60. {
  61.   struct nonblocking_fd *i = (struct nonblocking_fd *) o;
  62.   mark((struct ol_object *) i->next);
  63.   mark((struct ol_object *) i->close_callback);
  64. }
  65.  
  66. static void do_nonblocking_fd_free(struct ol_object *o)
  67. {
  68.   struct nonblocking_fd *i = (struct nonblocking_fd *) o;
  69.   ol_string_free(i->fname);
  70. }
  71.  
  72. struct ol_class nonblocking_fd_class =
  73. { STATIC_HEADER,
  74.   &resource_class, "nonblocking_fd", sizeof(struct nonblocking_fd),
  75.   do_nonblocking_fd_mark,
  76.   do_nonblocking_fd_free
  77. };
  78. #endif /* !CLASS_DECLARE */
  79.  
  80. #ifndef CLASS_DEFINE
  81. struct io_fd
  82. {
  83.   struct nonblocking_fd super;
  84.   int fsync;
  85.   struct read_handler *handler;
  86.   struct abstract_buffer *buffer;
  87. };
  88. extern struct ol_class io_fd_class;
  89. #endif /* !CLASS_DEFINE */
  90.  
  91. #ifndef CLASS_DECLARE
  92. static void do_io_fd_mark(struct ol_object *o, 
  93. void (*mark)(struct ol_object *o))
  94. {
  95.   struct io_fd *i = (struct io_fd *) o;
  96.   mark((struct ol_object *) i->handler);
  97.   mark((struct ol_object *) i->buffer);
  98. }
  99.  
  100. struct ol_class io_fd_class =
  101. { STATIC_HEADER,
  102.   &nonblocking_fd_class, "io_fd", sizeof(struct io_fd),
  103.   do_io_fd_mark,
  104.   NULL
  105. };
  106. #endif /* !CLASS_DECLARE */
  107.  
  108. #ifndef CLASS_DEFINE
  109. struct address_info
  110. {
  111.   struct ol_object super;
  112.   int family;
  113.   int (*(convert2sockaddr))(struct address_info *self, int, struct sockaddr *);
  114.   int (*(bind_socket))(struct address_info *self, int);
  115.   int (*(connect_socket))(struct address_info *self, int);
  116. };
  117. extern struct ol_class address_info_class;
  118. #endif /* !CLASS_DEFINE */
  119.  
  120. #ifndef CLASS_DECLARE
  121. struct ol_class address_info_class =
  122. { STATIC_HEADER,
  123.   0, "address_info", sizeof(struct address_info),
  124.   NULL,
  125.   NULL
  126. };
  127. #endif /* !CLASS_DECLARE */
  128.  
  129. #ifndef CLASS_DEFINE
  130. struct unix_address_info
  131. {
  132.   struct address_info super;
  133.   struct ol_string *path;
  134. };
  135. extern struct ol_class unix_address_info_class;
  136. #endif /* !CLASS_DEFINE */
  137.  
  138. #ifndef CLASS_DECLARE
  139. static void do_unix_address_info_free(struct ol_object *o)
  140. {
  141.   struct unix_address_info *i = (struct unix_address_info *) o;
  142.   ol_string_free(i->path);
  143. }
  144.  
  145. struct ol_class unix_address_info_class =
  146. { STATIC_HEADER,
  147.   &address_info_class, "unix_address_info", sizeof(struct unix_address_info),
  148.   NULL,
  149.   do_unix_address_info_free
  150. };
  151. #endif /* !CLASS_DECLARE */
  152.  
  153. #ifndef CLASS_DEFINE
  154. struct inet_address_info
  155. {
  156.   struct address_info super;
  157.   struct ol_string *ip;
  158.   struct sockaddr_in sa;
  159.   UINT32 port;
  160. };
  161. extern struct ol_class inet_address_info_class;
  162. #endif /* !CLASS_DEFINE */
  163.  
  164. #ifndef CLASS_DECLARE
  165. static void do_inet_address_info_free(struct ol_object *o)
  166. {
  167.   struct inet_address_info *i = (struct inet_address_info *) o;
  168.   ol_string_free(i->ip);
  169. }
  170.  
  171. struct ol_class inet_address_info_class =
  172. { STATIC_HEADER,
  173.   &address_info_class, "inet_address_info", sizeof(struct inet_address_info),
  174.   NULL,
  175.   do_inet_address_info_free
  176. };
  177. #endif /* !CLASS_DECLARE */
  178.  
  179. #ifndef CLASS_DEFINE
  180. struct fd_listen_callback
  181. {
  182.   struct ol_object super;
  183.   int (*(f))(struct fd_listen_callback *self, int, struct address_info *);
  184. };
  185. extern struct ol_class fd_listen_callback_class;
  186. #endif /* !CLASS_DEFINE */
  187.  
  188. #ifndef CLASS_DECLARE
  189. struct ol_class fd_listen_callback_class =
  190. { STATIC_HEADER,
  191.   0, "fd_listen_callback", sizeof(struct fd_listen_callback),
  192.   NULL,
  193.   NULL
  194. };
  195. #endif /* !CLASS_DECLARE */
  196.  
  197. #ifndef CLASS_DEFINE
  198. struct listen_fd
  199. {
  200.   struct nonblocking_fd super;
  201.   struct fd_listen_callback *callback;
  202. };
  203. extern struct ol_class listen_fd_class;
  204. #endif /* !CLASS_DEFINE */
  205.  
  206. #ifndef CLASS_DECLARE
  207. static void do_listen_fd_mark(struct ol_object *o, 
  208. void (*mark)(struct ol_object *o))
  209. {
  210.   struct listen_fd *i = (struct listen_fd *) o;
  211.   mark((struct ol_object *) i->callback);
  212. }
  213.  
  214. struct ol_class listen_fd_class =
  215. { STATIC_HEADER,
  216.   &nonblocking_fd_class, "listen_fd", sizeof(struct listen_fd),
  217.   do_listen_fd_mark,
  218.   NULL
  219. };
  220. #endif /* !CLASS_DECLARE */
  221.  
  222. #ifndef CLASS_DEFINE
  223. struct connect_fd
  224. {
  225.   struct nonblocking_fd super;
  226.   struct fd_callback *callback;
  227. };
  228. extern struct ol_class connect_fd_class;
  229. #endif /* !CLASS_DEFINE */
  230.  
  231. #ifndef CLASS_DECLARE
  232. static void do_connect_fd_mark(struct ol_object *o, 
  233. void (*mark)(struct ol_object *o))
  234. {
  235.   struct connect_fd *i = (struct connect_fd *) o;
  236.   mark((struct ol_object *) i->callback);
  237. }
  238.  
  239. struct ol_class connect_fd_class =
  240. { STATIC_HEADER,
  241.   &nonblocking_fd_class, "connect_fd", sizeof(struct connect_fd),
  242.   do_connect_fd_mark,
  243.   NULL
  244. };
  245. #endif /* !CLASS_DECLARE */
  246.  
  247. #ifndef CLASS_DEFINE
  248. struct callback
  249. {
  250.   struct ol_object super;
  251.   void (*(f))(struct callback *self);
  252. };
  253. extern struct ol_class callback_class;
  254. #endif /* !CLASS_DEFINE */
  255.  
  256. #ifndef CLASS_DECLARE
  257. struct ol_class callback_class =
  258. { STATIC_HEADER,
  259.   0, "callback", sizeof(struct callback),
  260.   NULL,
  261.   NULL
  262. };
  263. #endif /* !CLASS_DECLARE */
  264.  
  265. #ifndef CLASS_DEFINE
  266. struct io_backend
  267. {
  268.   struct ol_object super;
  269.   int reloading;
  270.   struct nonblocking_fd *files;
  271.   struct ol_queue callouts;
  272. };
  273. extern struct ol_class io_backend_class;
  274. #endif /* !CLASS_DEFINE */
  275.  
  276. #ifndef CLASS_DECLARE
  277. static void do_io_backend_mark(struct ol_object *o, 
  278. void (*mark)(struct ol_object *o))
  279. {
  280.   struct io_backend *i = (struct io_backend *) o;
  281.   mark((struct ol_object *) i->files);
  282.   do_mark_callouts(&(i->callouts), mark);
  283. }
  284.  
  285. static void do_io_backend_free(struct ol_object *o)
  286. {
  287.   struct io_backend *i = (struct io_backend *) o;
  288.   do_free_callouts(&(i->callouts));
  289. }
  290.  
  291. struct ol_class io_backend_class =
  292. { STATIC_HEADER,
  293.   0, "io_backend", sizeof(struct io_backend),
  294.   do_io_backend_mark,
  295.   do_io_backend_free
  296. };
  297. #endif /* !CLASS_DECLARE */
  298.  
  299.